home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / info.lzh / INFO / GCC_INFO.7 < prev    next >
Encoding:
GNU Info File  |  1993-10-21  |  51.1 KB  |  1,180 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.  
  4.    This file documents the use and the internals of the GNU compiler.
  5.  
  6.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the sections entitled "GNU General Public License" and "Protect
  15. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  16. original, and provided that the entire resulting derived work is
  17. distributed under the terms of a permission notice identical to this
  18. one.
  19.  
  20.    Permission is granted to copy and distribute translations of this
  21. manual into another language, under the above conditions for modified
  22. versions, except that the sections entitled "GNU General Public
  23. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  24. permission notice, may be included in translations approved by the Free
  25. Software Foundation instead of in the original English.
  26.  
  28. File: gcc.info,  Node: Naming Results,  Next: Min and Max,  Up: C++ Extensions
  29.  
  30. Named Return Values in C++
  31. ==========================
  32.  
  33.    GNU C++ extends the function-definition syntax to allow you to
  34. specify a name for the result of a function outside the body of the
  35. definition, in C++ programs:
  36.  
  37.      TYPE
  38.      FUNCTIONNAME (ARGS) return RESULTNAME;
  39.      {
  40.        ...
  41.        BODY
  42.        ...
  43.      }
  44.  
  45.    You can use this feature to avoid an extra constructor call when a
  46. function result has a class type.  For example, consider a function
  47. `m', declared as `X v = m ();', whose result is of class `X':
  48.  
  49.      X
  50.      m ()
  51.      {
  52.        X b;
  53.        b.a = 23;
  54.        return b;
  55.      }
  56.  
  57.    Although `m' appears to have no arguments, in fact it has one
  58. implicit argument: the address of the return value.  At invocation, the
  59. address of enough space to hold `v' is sent in as the implicit argument.
  60. Then `b' is constructed and its `a' field is set to the value 23.
  61. Finally, a copy constructor (a constructor of the form `X(X&)') is
  62. applied to `b', with the (implicit) return value location as the
  63. target, so that `v' is now bound to the return value.
  64.  
  65.    But this is wasteful.  The local `b' is declared just to hold
  66. something that will be copied right out.  While a compiler that
  67. combined an "elision" algorithm with interprocedural data flow analysis
  68. could conceivably eliminate all of this, it is much more practical to
  69. allow you to assist the compiler in generating efficient code by
  70. manipulating the return value explicitly, thus avoiding the local
  71. variable and copy constructor altogether.
  72.  
  73.    Using the extended GNU C++ function-definition syntax, you can avoid
  74. the temporary allocation and copying by naming `r' as your return value
  75. as the outset, and assigning to its `a' field directly:
  76.  
  77.      X
  78.      m () return r;
  79.      {
  80.        r.a = 23;
  81.      }
  82.  
  83. The declaration of `r' is a standard, proper declaration, whose effects
  84. are executed *before* any of the body of `m'.
  85.  
  86.    Functions of this type impose no additional restrictions; in
  87. particular, you can execute `return' statements, or return implicitly by
  88. reaching the end of the function body ("falling off the edge").  Cases
  89. like
  90.  
  91.      X
  92.      m () return r (23);
  93.      {
  94.        return;
  95.      }
  96.  
  97. (or even `X m () return r (23); { }') are unambiguous, since the return
  98. value `r' has been initialized in either case.  The following code may
  99. be hard to read, but also works predictably:
  100.  
  101.      X
  102.      m () return r;
  103.      {
  104.        X b;
  105.        return b;
  106.      }
  107.  
  108.    The return value slot denoted by `r' is initialized at the outset,
  109. but the statement `return b;' overrides this value.  The compiler deals
  110. with this by destroying `r' (calling the destructor if there is one, or
  111. doing nothing if there is not), and then reinitializing `r' with `b'.
  112.  
  113.    This extension is provided primarily to help people who use
  114. overloaded operators, where there is a great need to control not just
  115. the arguments, but the return values of functions.  For classes where
  116. the copy constructor incurs a heavy performance penalty (especially in
  117. the common case where there is a quick default constructor), this is a
  118. major savings.  The disadvantage of this extension is that you do not
  119. control when the default constructor for the return value is called: it
  120. is always called at the beginning.
  121.  
  123. File: gcc.info,  Node: Min and Max,  Next: Destructors and Goto,  Prev: Naming Results,  Up: C++ Extensions
  124.  
  125. Minimum and Maximum Operators in C++
  126. ====================================
  127.  
  128.    It is very convenient to have operators which return the "minimum"
  129. or the "maximum" of two arguments.  In GNU C++ (but not in GNU C),
  130.  
  131. `A <? B'
  132.      is the "minimum", returning the smaller of the numeric values A
  133.      and B;
  134.  
  135. `A >? B'
  136.      is the "maximum", returning the larger of the numeric values A and
  137.      B.
  138.  
  139.    These operations are not primitive in ordinary C++, since you can
  140. use a macro to return the minimum of two things in C++, as in the
  141. following example.
  142.  
  143.      #define MIN(X,Y) ((X) < (Y) ? : (X) : (Y))
  144.  
  145. You might then use `int min = MIN (i, j);' to set MIN to the minimum
  146. value of variables I and J.
  147.  
  148.    However, side effects in `X' or `Y' may cause unintended behavior.
  149. For example, `MIN (i++, j++)' will fail, incrementing the smaller
  150. counter twice.  A GNU C extension allows you to write safe macros that
  151. avoid this kind of problem (*note Naming an Expression's Type: Naming
  152. Types.).  However, writing `MIN' and `MAX' as macros also forces you to
  153. use function-call notation notation for a fundamental arithmetic
  154. operation.  Using GNU C++ extensions, you can write `int min = i <? j;'
  155. instead.
  156.  
  157.    Since `<?' and `>?' are built into the compiler, they properly
  158. handle expressions with side-effects;  `int min = i++ <? j++;' works
  159. correctly.
  160.  
  162. File: gcc.info,  Node: Destructors and Goto,  Next: C++ Interface,  Prev: Min and Max,  Up: C++ Extensions
  163.  
  164. `goto' and Destructors in GNU C++
  165. =================================
  166.  
  167.    In C++ programs, you can safely use the `goto' statement.  When you
  168. use it to exit a block which contains aggregates requiring destructors,
  169. the destructors will run before the `goto' transfers control.  (In ANSI
  170. C++, `goto' is restricted to targets within the current block.)
  171.  
  172.    The compiler still forbids using `goto' to *enter* a scope that
  173. requires constructors.
  174.  
  176. File: gcc.info,  Node: C++ Interface,  Prev: Destructors and Goto,  Up: C++ Extensions
  177.  
  178. Declarations and Definitions in One Header
  179. ==========================================
  180.  
  181.    C++ object definitions can be quite complex.  In principle, your
  182. source code will need two kinds of things for each object that you use
  183. across more than one source file.  First, you need an "interface"
  184. specification, describing its structure with type declarations and
  185. function prototypes.  Second, you need the "implementation" itself.  It
  186. can be tedious to maintain a separate interface description in a header
  187. file, in parallel to the actual implementation.  It is also dangerous,
  188. since separate interface and implementation definitions may not remain
  189. parallel.
  190.  
  191.    With GNU C++, you can use a single header file for both purposes.
  192.  
  193.      *Warning:* The mechanism to specify this is in transition.  For the
  194.      nonce, you must use one of two `#pragma' commands; in a future
  195.      release of GNU C++, an alternative mechanism will make these
  196.      `#pragma' commands unnecessary.
  197.  
  198.    The header file contains the full definitions, but is marked with
  199. `#pragma interface' in the source code.  This allows the compiler to
  200. use the header file only as an interface specification when ordinary
  201. source files incorporate it with `#include'.  In the single source file
  202. where the full implementation belongs, you can use either a naming
  203. convention or `#pragma implementation' to indicate this alternate use
  204. of the header file.
  205.  
  206. `#pragma interface'
  207.      Use this directive in *header files* that define object classes,
  208.      to save space in most of the object files that use those classes.
  209.      Normally, local copies of certain information (backup copies of
  210.      inline member functions, debugging information, and the internal
  211.      tables that implement virtual functions) must be kept in each
  212.      object file that includes class definitions.  You can use this
  213.      pragma to avoid such duplication.  When a header file containing
  214.      `#pragma interface' is included in a compilation, this auxiliary
  215.      information will not be generated (unless the main input source
  216.      file itself uses `#pragma implementation').  Instead, the object
  217.      files will contain references to be resolved at link time.
  218.  
  219. `#pragma implementation'
  220. `#pragma implementation "OBJECTS.h"'
  221.      Use this pragma in a *main input file*, when you want full output
  222.      from included header files to be generated (and made globally
  223.      visible).  The included header file, in turn, should use `#pragma
  224.      interface'.  Backup copies of inline member functions, debugging
  225.      information, and the internal tables used to implement virtual
  226.      functions are all generated in implementation files.
  227.  
  228.      `#pragma implementation' is *implied* whenever the basename(1) of
  229.      your source file matches the basename of a header file it
  230.      includes.  There is no way to turn this off (other than using a
  231.      different name for one of the two files).  In the same vein, if
  232.      you use `#pragma implementation' with no argument, it applies to an
  233.      include file with the same basename as your source file.  For
  234.      example, in `allclass.cc', `#pragma implementation' by itself is
  235.      equivalent to `#pragma implementation "allclass.h"'; but even if
  236.      you do not say `#pragma implementation' at all, `allclass.h' is
  237.      treated as an implementation file whenever you include it from
  238.      `allclass.cc'.
  239.  
  240.      If you use an explicit `#pragma implementation', it must appear in
  241.      your source file *before* you include the affected header files.
  242.  
  243.      Use the string argument if you want a single implementation file to
  244.      include code from multiple header files.  (You must also use
  245.      `#include' to include the header file; `#pragma implementation'
  246.      only specifies how to use the file--it doesn't actually include
  247.      it.)
  248.  
  249.      There is no way to split up the contents of a single header file
  250.      into multiple implementation files.
  251.  
  252.    `#pragma implementation' and `#pragma interface' also have an effect
  253. on function inlining.
  254.  
  255.    If you define a class in a header file marked with `#pragma
  256. interface', the effect on a function defined in that class is similar to
  257. an explicit `extern' declaration--the compiler emits no code at all to
  258. define an independent version of the function.  Its definition is used
  259. only for inlining with its callers.
  260.  
  261.    Conversely, when you include the same header file in a main source
  262. file that declares it as `#pragma implementation', the compiler emits
  263. code for the function itself; this defines a version of the function
  264. that can be found via pointers (or by callers compiled without
  265. inlining).
  266.  
  267.    ---------- Footnotes ----------
  268.  
  269.    (1)  A file's "basename" is the name stripped of all leading path
  270. information and of trailing suffixes, such as `.h' or `.C' or `.cc'.
  271.  
  273. File: gcc.info,  Node: Trouble,  Next: Bugs,  Prev: C++ Extensions,  Up: Top
  274.  
  275. Known Causes of Trouble with GNU CC
  276. ***********************************
  277.  
  278.    This section describes known problems that affect users of GNU CC.
  279. Most of these are not GNU CC bugs per se--if they were, we would fix
  280. them.  But the result for a user may be like the result of a bug.
  281.  
  282.    Some of these problems are due to bugs in other software, some are
  283. missing features that are too much work to add, and some are places
  284. where people's opinions differ as to what is best.
  285.  
  286. * Menu:
  287.  
  288. * Actual Bugs::              Bugs we will fix later.
  289. * Installation Problems::     Problems that manifest when you install GNU CC.
  290. * Cross-Compiler Problems::   Common problems of cross compiling with GNU CC.
  291. * Interoperation::      Problems using GNU CC with other compilers,
  292.                and with certain linkers, assemblers and debuggers.
  293. * External Bugs::    Problems compiling certain programs.
  294. * Incompatibilities::   GNU CC is incompatible with traditional C.
  295. * Disappointments::     Regrettable things we can't change, but not quite bugs.
  296. * C++ Misunderstandings::     Common misunderstandings with GNU C++.
  297. * Protoize Caveats::    Things to watch out for when using `protoize'.
  298. * Non-bugs::        Things we think are right, but some others disagree.
  299. * Warnings and Errors:: Which problems in your code get warnings,
  300.                          and which get errors.
  301.  
  303. File: gcc.info,  Node: Actual Bugs,  Next: Installation Problems,  Up: Trouble
  304.  
  305. Actual Bugs We Haven't Fixed Yet
  306. ================================
  307.  
  308.    * The `fixincludes' script interacts badly with automounters; if the
  309.      directory of system header files is automounted, it tends to be
  310.      unmounted while `fixincludes' is running.  This would seem to be a
  311.      bug in the automounter.  We don't know any good way to work around
  312.      it.
  313.  
  314.    * Loop unrolling doesn't work properly for certain C++ programs.
  315.      This is because of difficulty in updating the debugging
  316.      information within the loop being unrolled.  We plan to revamp the
  317.      representation of debugging information so that this will work
  318.      properly, but we have not done this in version 2.4 because we
  319.      don't want to delay it any further.
  320.  
  322. File: gcc.info,  Node: Installation Problems,  Next: Cross-Compiler Problems,  Prev: Actual Bugs,  Up: Trouble
  323.  
  324. Installation Problems
  325. =====================
  326.  
  327.    This is a list of problems (and some apparent problems which don't
  328. really mean anything is wrong) that show up during installation of GNU
  329. CC.
  330.  
  331.    * On certain systems, defining certain environment variables such as
  332.      `CC' can interfere with the functioning of `make'.
  333.  
  334.    * If you encounter seemingly strange errors when trying to build the
  335.      compiler in a directory other than the source directory, it could
  336.      be because you have previously configured the compiler in the
  337.      source directory.  Make sure you have done all the necessary
  338.      preparations.  *Note Other Dir::.
  339.  
  340.    * In previous versions of GNU CC, the `gcc' driver program looked for
  341.      `as' and `ld' in various places such as files beginning with
  342.      `/usr/local/lib/gcc-'.  GNU CC version 2 looks for them in the
  343.      directory `/usr/local/lib/gcc-lib/TARGET/VERSION'.
  344.  
  345.      Thus, to use a version of `as' or `ld' that is not the system
  346.      default, for example `gas' or GNU `ld', you must put them in that
  347.      directory (or make links to them from that directory).
  348.  
  349.    * Some commands executed when making the compiler may fail (return a
  350.      non-zero status) and be ignored by `make'.  These failures, which
  351.      are often due to files that were not found, are expected, and can
  352.      safely be ignored.
  353.  
  354.    * It is normal to have warnings in compiling certain files about
  355.      unreachable code and about enumeration type clashes.  These files'
  356.      names begin with `insn-'.  Also, `real.c' may get some warnings
  357.      that you can ignore.
  358.  
  359.    * Sometimes `make' recompiles parts of the compiler when installing
  360.      the compiler.  In one case, this was traced down to a bug in
  361.      `make'.  Either ignore the problem or switch to GNU Make.
  362.  
  363.    * On some 386 systems, building the compiler never finishes because
  364.      `enquire' hangs due to a hardware problem in the motherboard--it
  365.      reports floating point exceptions to the kernel incorrectly.  You
  366.      can install GNU CC except for `float.h' by patching out the
  367.      command to run `enquire'.  You may also be able to fix the problem
  368.      for real by getting a replacement motherboard.  This problem was
  369.      observed in Revision E of the Micronics motherboard, and is fixed
  370.      in Revision F.
  371.  
  372.    * On some 386 systems, GNU CC crashes trying to compile `enquire.c'.
  373.      This happens on machines that don't have a 387 FPU chip.  On 386
  374.      machines, the system kernel is supposed to emulate the 387 when you
  375.      don't have one.  The crash is due to a bug in the emulator.
  376.  
  377.      One of these systems is the Unix from Interactive Systems: 386/ix.
  378.      On this system, an alternate emulator is provided, and it does
  379.      work.  To use it, execute this command as super-user:
  380.  
  381.           ln /etc/emulator.rel1 /etc/emulator
  382.  
  383.      and then reboot the system.  (The default emulator file remains
  384.      present under the name `emulator.dflt'.)
  385.  
  386.      Try using `/etc/emulator.att', if you have such a problem on the
  387.      SCO system.
  388.  
  389.      Another system which has this problem is Esix.  We don't know
  390.      whether it has an alternate emulator that works.
  391.  
  392.    * Sometimes on a Sun 4 you may observe a crash in the program
  393.      `genflags' or `genoutput' while building GNU CC.  This is said to
  394.      be due to a bug in `sh'.  You can probably get around it by running
  395.      `genflags' or `genoutput' manually and then retrying the `make'.
  396.  
  397.    * On Solaris 2, executables of GNU CC version 2.0.2 are commonly
  398.      available, but they have a bug that shows up when compiling current
  399.      versions of GNU CC: undefined symbol errors occur during assembly
  400.      if you use `-g'.
  401.  
  402.      The solution is to compile the current version of GNU CC without
  403.      `-g'.  That makes a working compiler which you can use to recompile
  404.      with `-g'.
  405.  
  406.    * Solaris 2 comes with a number of optional OS packages.  Six of
  407.      these packages are needed to use GNU CC fully.  If you did not
  408.      install all optional packages when installing Solaris, you will
  409.      need to verify that these six packages are installed.
  410.  
  411.      The six packages that GNU CC needs are: `SUNWarc', `SUNWbtool',
  412.      `SUNWesu', `SUNWhea', `SUNWlibm', and `SUNWtoo'.  To check whether
  413.      an optional package is installed, use the `pkginfo' command.  To
  414.      add an optional package, use the `pkgadd' command.  For further
  415.      details, see the Solaris documentation.
  416.  
  417.    * If you use the 1.31 version of the MIPS assembler (such as was
  418.      shipped with Ultrix 3.1), you will need to use the
  419.      -fno-delayed-branch switch when optimizing floating point code.
  420.      Otherwise, the assembler will complain when the GCC compiler fills
  421.      a branch delay slot with a floating point instruction, such as
  422.      add.d.
  423.  
  424.    * Users have reported some problems with version 2.0 of the MIPS
  425.      compiler tools that were shipped with Ultrix 4.1.  Version 2.10
  426.      which came with Ultrix 4.2 seems to work fine.
  427.  
  428.    * Some versions of the MIPS linker will issue an assertion failure
  429.      when linking code that uses `alloca' against shared libraries on
  430.      RISC-OS 5.0, and DEC's OSF/1 systems.  This is a bug in the
  431.      linker, that is supposed to be fixed in future revisions.  To
  432.      protect against this, GCC passes `-non_shared' to the linker
  433.      unless you pass an explicit `-shared' or `-call_shared' switch.
  434.  
  435.    * On System V release 3, you may get this error message while
  436.      linking:
  437.  
  438.           ld fatal: failed to write symbol name SOMETHING
  439.            in strings table for file WHATEVER
  440.  
  441.      This probably indicates that the disk is full or your ULIMIT won't
  442.      allow the file to be as large as it needs to be.
  443.  
  444.      This problem can also result because the kernel parameter `MAXUMEM'
  445.      is too small.  If so, you must regenerate the kernel and make the
  446.      value much larger.  The default value is reported to be 1024; a
  447.      value of 32768 is said to work.  Smaller values may also work.
  448.  
  449.    * On System V, if you get an error like this,
  450.  
  451.           /usr/local/lib/bison.simple: In function `yyparse':
  452.           /usr/local/lib/bison.simple:625: virtual memory exhausted
  453.  
  454.      that too indicates a problem with disk space, ULIMIT, or `MAXUMEM'.
  455.  
  456.    * On the Tower models 4N0 and 6N0, by default a process is not
  457.      allowed to have more than one megabyte of memory.  GNU CC cannot
  458.      compile itself (or many other programs) with `-O' in that much
  459.      memory.
  460.  
  461.      To solve this problem, reconfigure the kernel adding the following
  462.      line to the configuration file:
  463.  
  464.           MAXUMEM = 4096
  465.  
  466.    * On HP 9000 series 300 or 400 running HP-UX release 8.0, there is a
  467.      bug in the assembler that must be fixed before GNU CC can be
  468.      built.  This bug manifests itself during the first stage of
  469.      compilation, while building `libgcc2.a':
  470.  
  471.           _floatdisf
  472.           cc1: warning: `-g' option not supported on this version of GCC
  473.           cc1: warning: `-g1' option not supported on this version of GCC
  474.           ./xgcc: Internal compiler error: program as got fatal signal 11
  475.  
  476.      A patched version of the assembler is available by anonymous ftp
  477.      from `altdorf.ai.mit.edu' as the file
  478.      `archive/cph/hpux-8.0-assembler'.  If you have HP software support,
  479.      the patch can also be obtained directly from HP, as described in
  480.      the following note:
  481.  
  482.           This is the patched assembler, to patch SR#1653-010439, where
  483.           the assembler aborts on floating point constants.
  484.  
  485.           The bug is not really in the assembler, but in the shared
  486.           library version of the function "cvtnum(3c)".  The bug on
  487.           "cvtnum(3c)" is SR#4701-078451.  Anyway, the attached
  488.           assembler uses the archive library version of "cvtnum(3c)"
  489.           and thus does not exhibit the bug.
  490.  
  491.      This patch is also known as PHCO_0800.
  492.  
  493.    * To build GCC for HP PA model 1.1 machines running HP-UX versions
  494.      earlier than 8.07, you have to configure for HP PA model 1.0.
  495.      This is because a bug in the PA configuration that probably will
  496.      be fixed in the next release of the compiler.
  497.  
  498.    * On HP-UX version 9.01 on the HP PA, the HP compiler `cc' does not
  499.      compile GNU CC correctly.  We do not yet know why.  However, GNU CC
  500.      compiled on earlier HP-UX versions works properly on HP-UX 9.01
  501.      and can compile itself properly on 9.01.
  502.  
  503.    * Another assembler problem on the HP PA results in an error message
  504.      like this while compiling part of `libgcc2.a':
  505.  
  506.           as: /usr/tmp/cca08196.s @line#30 [err#1060]
  507.             Argument 1 or 3 in FARG upper
  508.                    - lookahead = RTNVAL=GR
  509.  
  510.      This happens because HP changed the assembler syntax after system
  511.      release 8.02.  GNU CC assumes the newer syntax; if your assembler
  512.      wants the older syntax, comment out this line in the file
  513.      `pa1-hpux.h':
  514.  
  515.           #define HP_FP_ARG_DESCRIPTOR_REVERSED
  516.  
  517.    * Some versions of the Pyramid C compiler are reported to be unable
  518.      to compile GNU CC.  You must use an older version of GNU CC for
  519.      bootstrapping.  One indication of this problem is if you get a
  520.      crash when GNU CC compiles the function `muldi3' in file
  521.      `libgcc2.c'.
  522.  
  523.      You may be able to succeed by getting GNU CC version 1, installing
  524.      it, and using it to compile GNU CC version 2.  The bug in the
  525.      Pyramid C compiler does not seem to affect GNU CC version 1.
  526.  
  527.    * There may be similar problems on System V Release 3.1 on 386
  528.      systems.
  529.  
  530.    * On the Altos 3068, programs compiled with GNU CC won't work unless
  531.      you fix a kernel bug.  This happens using system versions V.2.2
  532.      1.0gT1 and V.2.2 1.0e and perhaps later versions as well.  See the
  533.      file `README.ALTOS'.
  534.  
  535.    * You will get several sorts of compilation and linking errors on the
  536.      we32k if you don't follow the special instructions.  *Note WE32K
  537.      Install::.
  538.  
  540. File: gcc.info,  Node: Cross-Compiler Problems,  Next: Interoperation,  Prev: Installation Problems,  Up: Trouble
  541.  
  542. Cross-Compiler Problems
  543. =======================
  544.  
  545.    You may run into problems with cross compilation on certain machines,
  546. for several reasons.
  547.  
  548.    * Cross compilation can run into trouble for certain machines because
  549.      some target machines' assemblers require floating point numbers to
  550.      be written as *integer* constants in certain contexts.
  551.  
  552.      The compiler writes these integer constants by examining the
  553.      floating point value as an integer and printing that integer,
  554.      because this is simple to write and independent of the details of
  555.      the floating point representation.  But this does not work if the
  556.      compiler is running on a different machine with an incompatible
  557.      floating point format, or even a different byte-ordering.
  558.  
  559.      In addition, correct constant folding of floating point values
  560.      requires representing them in the target machine's format.  (The C
  561.      standard does not quite require this, but in practice it is the
  562.      only way to win.)
  563.  
  564.      It is now possible to overcome these problems by defining macros
  565.      such as `REAL_VALUE_TYPE'.  But doing so is a substantial amount of
  566.      work for each target machine.  *Note Cross-compilation::.
  567.  
  568.    * At present, the program `mips-tfile' which adds debug support to
  569.      object files on MIPS systems does not work in a cross compile
  570.      environment.
  571.  
  573. File: gcc.info,  Node: Interoperation,  Next: External Bugs,  Prev: Cross-Compiler Problems,  Up: Trouble
  574.  
  575. Interoperation
  576. ==============
  577.  
  578.    This section lists various difficulties encountered in using GNU C or
  579. GNU C++ together with other compilers or with the assemblers, linkers,
  580. libraries and debuggers on certain systems.
  581.  
  582.    * GNU C normally compiles functions to return small structures and
  583.      unions in registers.  Most other compilers arrange to return them
  584.      just like larger structures and unions.  This can lead to trouble
  585.      when you link together code compiled by different compilers.  To
  586.      avoid the problem, you can use the option `-fpcc-struct-return'
  587.      when compiling with GNU CC.
  588.  
  589.    * GNU C++ does not do name mangling in the same way as other C++
  590.      compilers.  This means that object files compiled with one compiler
  591.      cannot be used with another.
  592.  
  593.      This effect is intentional, to protect you from more subtle
  594.      problems.  Compilers differ as to many internal details of C++
  595.      implementation, including: how class instances are laid out, how
  596.      multiple inheritance is implemented, and how virtual function
  597.      calls are handled.  If the name encoding were made the same, your
  598.      programs would link against libraries provided from other
  599.      compilers--but the programs would then crash when run.
  600.      Incompatible libraries are then detected at link time, rather than
  601.      at run time.
  602.  
  603.    * Older GDB versions sometimes fail to read the output of GNU CC
  604.      version 2.  If you have trouble, get GDB version 4.4 or later.
  605.  
  606.    * DBX rejects some files produced by GNU CC, though it accepts
  607.      similar constructs in output from PCC.  Until someone can supply a
  608.      coherent description of what is valid DBX input and what is not,
  609.      there is nothing I can do about these problems.  You are on your
  610.      own.
  611.  
  612.    * The GNU assembler (GAS) does not support PIC.  To generate PIC
  613.      code, you must use some other assembler, such as `/bin/as'.
  614.  
  615.    * On some BSD systems including some versions of Ultrix, use of
  616.      profiling causes static variable destructors (currently used only
  617.      in C++) not to be run.
  618.  
  619.    * Use of `-I/usr/include' may cause trouble.
  620.  
  621.      Many systems come with header files that won't work with GNU CC
  622.      unless corrected by `fixincludes'.  The corrected header files go
  623.      in a new directory; GNU CC searches this directory before
  624.      `/usr/include'.  If you use `-I/usr/include', this tells GNU CC to
  625.      search `/usr/include' earlier on, before the corrected headers.
  626.      The result is that you get the uncorrected header files.
  627.  
  628.      Instead, you should use these options (when compiling C programs):
  629.  
  630.           -I/usr/local/lib/gcc-lib/TARGET/VERSION/include -I/usr/include
  631.  
  632.      For C++ programs, GNU CC also uses a special directory that
  633.      defines C++ interfaces to standard C subroutines.  This directory
  634.      is meant to be searched *before* other standard include
  635.      directories, so that it takes precedence.  If you are compiling
  636.      C++ programs and specifying include directories explicitly, use
  637.      this option first, then the two options above:
  638.  
  639.           -I/usr/local/lib/g++-include
  640.  
  641.    * On a Sparc, GNU CC aligns all values of type `double' on an 8-byte
  642.      boundary, and it expects every `double' to be so aligned.  The Sun
  643.      compiler usually gives `double' values 8-byte alignment, with one
  644.      exception: function arguments of type `double' may not be aligned.
  645.  
  646.      As a result, if a function compiled with Sun CC takes the address
  647.      of an argument of type `double' and passes this pointer of type
  648.      `double *' to a function compiled with GNU CC, dereferencing the
  649.      pointer may cause a fatal signal.
  650.  
  651.      One way to solve this problem is to compile your entire program
  652.      with GNU CC.  Another solution is to modify the function that is
  653.      compiled with Sun CC to copy the argument into a local variable;
  654.      local variables are always properly aligned.  A third solution is
  655.      to modify the function that uses the pointer to dereference it via
  656.      the following function `access_double' instead of directly with
  657.      `*':
  658.  
  659.           inline double
  660.           access_double (double *unaligned_ptr)
  661.           {
  662.             union d2i { double d; int i[2]; };
  663.           
  664.             union d2i *p = (union d2i *) unaligned_ptr;
  665.             union d2i u;
  666.           
  667.             u.i[0] = p->i[0];
  668.             u.i[1] = p->i[1];
  669.           
  670.             return u.d;
  671.           }
  672.  
  673.      Storing into the pointer can be done likewise with the same union.
  674.  
  675.    * On Solaris, the `malloc' function in the `libmalloc.a' library may
  676.      allocate memory that is only 4 byte aligned.  Since GNU CC on the
  677.      Sparc assumes that doubles are 8 byte aligned, this may result in a
  678.      fatal signal if doubles are stored in memory allocated by the
  679.      `libmalloc.a' library.
  680.  
  681.      The solution is to not use the `libmalloc.a' library.  Use instead
  682.      `malloc' and related functions from `libc.a'; they do not have
  683.      this problem.
  684.  
  685.    * On a Sun, linking using GNU CC fails to find a shared library and
  686.      reports that the library doesn't exist at all.
  687.  
  688.      This happens if you are using the GNU linker, because it does only
  689.      static linking and looks only for unshared libraries.  If you have
  690.      a shared library with no unshared counterpart, the GNU linker
  691.      won't find anything.
  692.  
  693.      We hope to make a linker which supports Sun shared libraries, but
  694.      please don't ask when it will be finished--we don't know.
  695.  
  696.    * Sun forgot to include a static version of `libdl.a' with some
  697.      versions of SunOS (mainly 4.1).  This results in undefined symbols
  698.      when linking static binaries (that is, if you use `-static').  If
  699.      you see undefined symbols `_dlclose', `_dlsym' or `_dlopen' when
  700.      linking, compile and link against the file `mit/util/misc/dlsym.c'
  701.      from the MIT version of X windows.
  702.  
  703.    * On the HP PA machine, ADB sometimes fails to work on functions
  704.      compiled with GNU CC.  Specifically, it fails to work on functions
  705.      that use `alloca' or variable-size arrays.  This is because GNU CC
  706.      doesn't generate HP-UX unwind descriptors for such functions.  It
  707.      may even be impossible to generate them.
  708.  
  709.    * Debugging (`-g') is not supported on the HP PA machine, unless you
  710.      use the preliminary GNU tools (*note Installation::.).
  711.  
  712.    * The HP-UX linker has a bug which can cause programs which make use
  713.      of `const' variables to fail in unusual ways.  If your program
  714.      makes use of global `const' variables, we suggest you compile with
  715.      the following additional options:
  716.  
  717.           -Dconst="" -D__const="" -D__const__="" -fwritable-strings
  718.  
  719.      This will force the `const' variables into the DATA subspace which
  720.      will avoid the linker bug.
  721.  
  722.      Another option one might use to work around this problem is
  723.      `-mkernel'.  `-mkernel' changes how the address of variables is
  724.      computed to a sequence less likely to tickle the HP-UX linker bug.
  725.  
  726.      We hope to work around this problem in GNU CC 2.4, if HP does not
  727.      fix it.
  728.  
  729.    * Taking the address of a label may generate errors from the HP-UX
  730.      PA assembler.  GAS for the PA does not have this problem.
  731.  
  732.    * GNU CC produced code will not yet link against HP-UX 8.0 shared
  733.      libraries.  We expect to fix this problem in GNU CC 2.4.
  734.  
  735.    * GNU CC compiled code sometimes emits warnings from the HP-UX
  736.      assembler of the form:
  737.  
  738.           (warning) Use of GR3 when
  739.             frame >= 8192 may cause conflict.
  740.  
  741.      These warnings are harmless and can be safely ignored.
  742.  
  743.    * The current version of the assembler (`/bin/as') for the RS/6000
  744.      has certain problems that prevent the `-g' option in GCC from
  745.      working.  Note that `Makefile.in' uses `-g' by default when
  746.      compiling `libgcc2.c'.
  747.  
  748.      IBM has produced a fixed version of the assembler.  The upgraded
  749.      assembler unfortunately was not included in any of the AIX 3.2
  750.      update PTF releases (3.2.2, 3.2.3, or 3.2.3e).  Users of AIX 3.1
  751.      should request PTF U403044 from IBM and users of AIX 3.2 should
  752.      request PTF U416277.  See the file `README.RS6000' for more
  753.      details on these updates.
  754.  
  755.      You can test for the presense of a fixed assembler by using the
  756.      command
  757.  
  758.           as -u < /dev/null
  759.  
  760.      If the command exits normally, the assembler fix already is
  761.      installed.  If the assembler complains that "-u" is an unknown
  762.      flag, you need to order the fix.
  763.  
  764.    * On the IBM RS/6000, compiling code of the form
  765.  
  766.           extern int foo;
  767.           
  768.           ... foo ...
  769.           
  770.           static int foo;
  771.  
  772.      will cause the linker to report an undefined symbol `foo'.
  773.      Although this behavior differs from most other systems, it is not a
  774.      bug because redefining an `extern' variable as `static' is
  775.      undefined in ANSI C.
  776.  
  777.    * AIX on the RS/6000 provides support (NLS) for environments outside
  778.      of the United States.  Compilers and assemblers use NLS to support
  779.      locale-specific representations of various objects including
  780.      floating-point numbers ("." vs "," for separating decimal
  781.      fractions).  There have been problems reported where the library
  782.      linked with GCC does not produce the same floating-point formats
  783.      that the assembler accepts.  If you have this problem, set the
  784.      LANG environment variable to "C" or "En_US".
  785.  
  786.    * There is an assembler bug in versions of DG/UX prior to 5.4.2.01
  787.      that occurs when the `fldcr' instruction is used.  GNU CC uses
  788.      `fldcr' on the 88100 to serialize volatile memory references.  Use
  789.      the option `-fno-serialize-volatile' if your version of the
  790.      assembler has this bug.
  791.  
  792.    * On VMS, GAS versions 1.38.1 and earlier may cause spurious warning
  793.      messages from the linker.  These warning messages complain of
  794.      mismatched psect attributes.  You can ignore them.  *Note VMS
  795.      Install::.
  796.  
  797.    * On NewsOS version 3, if you include both of the files `stddef.h'
  798.      and `sys/types.h', you get an error because there are two typedefs
  799.      of `size_t'.  You should change `sys/types.h' by adding these
  800.      lines around the definition of `size_t':
  801.  
  802.           #ifndef _SIZE_T
  803.           #define _SIZE_T
  804.           ACTUAL TYPEDEF HERE
  805.           #endif
  806.  
  807.    * On the Alliant, the system's own convention for returning
  808.      structures and unions is unusual, and is not compatible with GNU
  809.      CC no matter what options are used.
  810.  
  811.    * On the IBM RT PC, the MetaWare HighC compiler (hc) uses yet another
  812.      convention for structure and union returning.  Use
  813.      `-mhc-struct-return' to tell GNU CC to use a convention compatible
  814.      with it.
  815.  
  816.    * On Ultrix, the Fortran compiler expects registers 2 through 5 to
  817.      be saved by function calls.  However, the C compiler uses
  818.      conventions compatible with BSD Unix: registers 2 through 5 may be
  819.      clobbered by function calls.
  820.  
  821.      GNU CC uses the same convention as the Ultrix C compiler.  You can
  822.      use these options to produce code compatible with the Fortran
  823.      compiler:
  824.  
  825.           -fcall-saved-r2 -fcall-saved-r3 -fcall-saved-r4 -fcall-saved-r5
  826.  
  827.    * On the WE32k, you may find that programs compiled with GNU CC do
  828.      not work with the standard shared C ilbrary.  You may need to link
  829.      with the ordinary C compiler.  If you do so, you must specify the
  830.      following options:
  831.  
  832.           -L/usr/local/lib/gcc-lib/we32k-att-sysv/2.4 -lgcc -lc_s
  833.  
  834.      The first specifies where to find the library `libgcc.a' specified
  835.      with the `-lgcc' option.
  836.  
  837.      GNU CC does linking by invoking `ld', just as `cc' does, and there
  838.      is no reason why it *should* matter which compilation program you
  839.      use to invoke `ld'.  If someone tracks this problem down, it can
  840.      probably be fixed easily.
  841.  
  843. File: gcc.info,  Node: External Bugs,  Next: Incompatibilities,  Prev: Interoperation,  Up: Trouble
  844.  
  845. Problems Compiling Certain Programs
  846. ===================================
  847.  
  848.    * Parse errors may occur compiling X11 on a Decstation running
  849.      Ultrix 4.2 because of problems in DEC's versions of the X11 header
  850.      files `X11/Xlib.h' and `X11/Xutil.h'.  People recommend adding
  851.      `-I/usr/include/mit' to use the MIT versions of the header files,
  852.      using the `-traditional' switch to turn off ANSI C, or fixing the
  853.      header files by adding this:
  854.  
  855.           #ifdef __STDC__
  856.           #define NeedFunctionPrototypes 0
  857.           #endif
  858.  
  860. File: gcc.info,  Node: Incompatibilities,  Next: Disappointments,  Prev: External Bugs,  Up: Trouble
  861.  
  862. Incompatibilities of GNU CC
  863. ===========================
  864.  
  865.    There are several noteworthy incompatibilities between GNU C and most
  866. existing (non-ANSI) versions of C.  The `-traditional' option
  867. eliminates many of these incompatibilities, *but not all*, by telling
  868. GNU C to behave like the other C compilers.
  869.  
  870.    * GNU CC normally makes string constants read-only.  If several
  871.      identical-looking string constants are used, GNU CC stores only one
  872.      copy of the string.
  873.  
  874.      One consequence is that you cannot call `mktemp' with a string
  875.      constant argument.  The function `mktemp' always alters the string
  876.      its argument points to.
  877.  
  878.      Another consequence is that `sscanf' does not work on some systems
  879.      when passed a string constant as its format control string or
  880.      input.  This is because `sscanf' incorrectly tries to write into
  881.      the string constant.  Likewise `fscanf' and `scanf'.
  882.  
  883.      The best solution to these problems is to change the program to use
  884.      `char'-array variables with initialization strings for these
  885.      purposes instead of string constants.  But if this is not possible,
  886.      you can use the `-fwritable-strings' flag, which directs GNU CC to
  887.      handle string constants the same way most C compilers do.
  888.      `-traditional' also has this effect, among others.
  889.  
  890.    * `-2147483648' is positive.
  891.  
  892.      This is because 2147483648 cannot fit in the type `int', so
  893.      (following the ANSI C rules) its data type is `unsigned long int'.
  894.      Negating this value yields 2147483648 again.
  895.  
  896.    * GNU CC does not substitute macro arguments when they appear inside
  897.      of string constants.  For example, the following macro in GNU CC
  898.  
  899.           #define foo(a) "a"
  900.  
  901.      will produce output `"a"' regardless of what the argument A is.
  902.  
  903.      The `-traditional' option directs GNU CC to handle such cases
  904.      (among others) in the old-fashioned (non-ANSI) fashion.
  905.  
  906.    * When you use `setjmp' and `longjmp', the only automatic variables
  907.      guaranteed to remain valid are those declared `volatile'.  This is
  908.      a consequence of automatic register allocation.  Consider this
  909.      function:
  910.  
  911.           jmp_buf j;
  912.           
  913.           foo ()
  914.           {
  915.             int a, b;
  916.           
  917.             a = fun1 ();
  918.             if (setjmp (j))
  919.               return a;
  920.           
  921.             a = fun2 ();
  922.             /* `longjmp (j)' may occur in `fun3'. */
  923.             return a + fun3 ();
  924.           }
  925.  
  926.      Here `a' may or may not be restored to its first value when the
  927.      `longjmp' occurs.  If `a' is allocated in a register, then its
  928.      first value is restored; otherwise, it keeps the last value stored
  929.      in it.
  930.  
  931.      If you use the `-W' option with the `-O' option, you will get a
  932.      warning when GNU CC thinks such a problem might be possible.
  933.  
  934.      The `-traditional' option directs GNU C to put variables in the
  935.      stack by default, rather than in registers, in functions that call
  936.      `setjmp'.  This results in the behavior found in traditional C
  937.      compilers.
  938.  
  939.    * Programs that use preprocessor directives in the middle of macro
  940.      arguments do not work with GNU CC.  For example, a program like
  941.      this will not work:
  942.  
  943.           foobar (
  944.           #define luser
  945.                   hack)
  946.  
  947.      ANSI C does not permit such a construct.  It would make sense to
  948.      support it when `-traditional' is used, but it is too much work to
  949.      implement.
  950.  
  951.    * Declarations of external variables and functions within a block
  952.      apply only to the block containing the declaration.  In other
  953.      words, they have the same scope as any other declaration in the
  954.      same place.
  955.  
  956.      In some other C compilers, a `extern' declaration affects all the
  957.      rest of the file even if it happens within a block.
  958.  
  959.      The `-traditional' option directs GNU C to treat all `extern'
  960.      declarations as global, like traditional compilers.
  961.  
  962.    * In traditional C, you can combine `long', etc., with a typedef
  963.      name, as shown here:
  964.  
  965.           typedef int foo;
  966.           typedef long foo bar;
  967.  
  968.      In ANSI C, this is not allowed: `long' and other type modifiers
  969.      require an explicit `int'.  Because this criterion is expressed by
  970.      Bison grammar rules rather than C code, the `-traditional' flag
  971.      cannot alter it.
  972.  
  973.    * PCC allows typedef names to be used as function parameters.  The
  974.      difficulty described immediately above applies here too.
  975.  
  976.    * PCC allows whitespace in the middle of compound assignment
  977.      operators such as `+='.  GNU CC, following the ANSI standard, does
  978.      not allow this.  The difficulty described immediately above
  979.      applies here too.
  980.  
  981.    * GNU CC complains about unterminated character constants inside of
  982.      preprocessor conditionals that fail.  Some programs have English
  983.      comments enclosed in conditionals that are guaranteed to fail; if
  984.      these comments contain apostrophes, GNU CC will probably report an
  985.      error.  For example, this code would produce an error:
  986.  
  987.           #if 0
  988.           You can't expect this to work.
  989.           #endif
  990.  
  991.      The best solution to such a problem is to put the text into an
  992.      actual C comment delimited by `/*...*/'.  However, `-traditional'
  993.      suppresses these error messages.
  994.  
  995.    * Many user programs contain the declaration `long time ();'.  In the
  996.      past, the system header files on many systems did not actually
  997.      declare `time', so it did not matter what type your program
  998.      declared it to return.  But in systems with ANSI C headers, `time'
  999.      is declared to return `time_t', and if that is not the same as
  1000.      `long', then `long time ();' is erroneous.
  1001.  
  1002.      The solution is to change your program to use `time_t' as the
  1003.      return type of `time'.
  1004.  
  1005.    * When compiling functions that return `float', PCC converts it to a
  1006.      double.  GNU CC actually returns a `float'.  If you are concerned
  1007.      with PCC compatibility, you should declare your functions to return
  1008.      `double'; you might as well say what you mean.
  1009.  
  1010.    * When compiling functions that return structures or unions, GNU CC
  1011.      output code normally uses a method different from that used on most
  1012.      versions of Unix.  As a result, code compiled with GNU CC cannot
  1013.      call a structure-returning function compiled with PCC, and vice
  1014.      versa.
  1015.  
  1016.      The method used by GNU CC is as follows: a structure or union
  1017.      which is 1, 2, 4 or 8 bytes long is returned like a scalar.  A
  1018.      structure or union with any other size is stored into an address
  1019.      supplied by the caller (usually in a special, fixed register, but
  1020.      on some machines it is passed on the stack).  The
  1021.      machine-description macros `STRUCT_VALUE' and
  1022.      `STRUCT_INCOMING_VALUE' tell GNU CC where to pass this address.
  1023.  
  1024.      By contrast, PCC on most target machines returns structures and
  1025.      unions of any size by copying the data into an area of static
  1026.      storage, and then returning the address of that storage as if it
  1027.      were a pointer value.  The caller must copy the data from that
  1028.      memory area to the place where the value is wanted.  GNU CC does
  1029.      not use this method because it is slower and nonreentrant.
  1030.  
  1031.      On some newer machines, PCC uses a reentrant convention for all
  1032.      structure and union returning.  GNU CC on most of these machines
  1033.      uses a compatible convention when returning structures and unions
  1034.      in memory, but still returns small structures and unions in
  1035.      registers.
  1036.  
  1037.      You can tell GNU CC to use a compatible convention for all
  1038.      structure and union returning with the option
  1039.      `-fpcc-struct-return'.
  1040.  
  1042. File: gcc.info,  Node: Disappointments,  Next: C++ Misunderstandings,  Prev: Incompatibilities,  Up: Trouble
  1043.  
  1044. Disappointments and Misunderstandings
  1045. =====================================
  1046.  
  1047.    These problems are perhaps regrettable, but we don't know any
  1048. practical way around them.
  1049.  
  1050.    * Certain local variables aren't recognized by debuggers when you
  1051.      compile with optimization.
  1052.  
  1053.      This occurs because sometimes GNU CC optimizes the variable out of
  1054.      existence.  There is no way to tell the debugger how to compute the
  1055.      value such a variable "would have had", and it is not clear that
  1056.      would be desirable anyway.  So GNU CC simply does not mention the
  1057.      eliminated variable when it writes debugging information.
  1058.  
  1059.      You have to expect a certain amount of disagreement between the
  1060.      executable and your source code, when you use optimization.
  1061.  
  1062.    * Users often think it is a bug when GNU CC reports an error for code
  1063.      like this:
  1064.  
  1065.           int foo (struct mumble *);
  1066.           
  1067.           struct mumble { ... };
  1068.           
  1069.           int foo (struct mumble *x)
  1070.           { ... }
  1071.  
  1072.      This code really is erroneous, because the scope of `struct
  1073.      mumble' in the prototype is limited to the argument list
  1074.      containing it.  It does not refer to the `struct mumble' defined
  1075.      with file scope immediately below--they are two unrelated types
  1076.      with similar names in different scopes.
  1077.  
  1078.      But in the definition of `foo', the file-scope type is used
  1079.      because that is available to be inherited.  Thus, the definition
  1080.      and the prototype do not match, and you get an error.
  1081.  
  1082.      This behavior may seem silly, but it's what the ANSI standard
  1083.      specifies.  It is easy enough for you to make your code work by
  1084.      moving the definition of `struct mumble' above the prototype.
  1085.      It's not worth being incompatible with ANSI C just to avoid an
  1086.      error for the example shown above.
  1087.  
  1088.    * Accesses to bitfields even in volatile objects works by accessing
  1089.      larger objects, such as a byte or a word.  You cannot rely on what
  1090.      size of object is accessed in order to read or write the bitfield;
  1091.      it may even vary for a given bitfield according to the precise
  1092.      usage.
  1093.  
  1094.      If you care about controlling the amount of memory that is
  1095.      accessed, use volatile but do not use bitfields.
  1096.  
  1097.    * GNU CC comes with shell scripts to fix certain known problems in
  1098.      system header files.  They install corrected copies of various
  1099.      header files in a special directory where only GNU CC will
  1100.      normally look for them.  The scripts adapt to various systems by
  1101.      searching all the system header files for the problem cases that
  1102.      we know about.
  1103.  
  1104.      If new system header files are installed, nothing automatically
  1105.      arranges to update the corrected header files.  You will have to
  1106.      reinstall GNU CC to fix the new header files.  More specifically,
  1107.      go to the build directory and delete the files `stmp-fixinc' and
  1108.      `stmp-headers', and the subdirectory `include'; then do `make
  1109.      install' again.
  1110.  
  1111.    * On 68000 systems, you can get paradoxical results if you test the
  1112.      precise values of floating point numbers.  For example, you can
  1113.      find that a floating point value which is not a NaN is not equal
  1114.      to itself.  This results from the fact that the the floating point
  1115.      registers hold a few more bits of precision than fit in a `double'
  1116.      in memory.  Compiled code moves values between memory and floating
  1117.      point registers at its convenience, and moving them into memory
  1118.      truncates them.
  1119.  
  1120.      You can partially avoid this problem by using the `-ffloat-store'
  1121.      option (*note Optimize Options::.).
  1122.  
  1123.    * On the MIPS, variable argument functions using `varargs.h' cannot
  1124.      have a floating point value for the first argument.  The reason
  1125.      for this is that in the absence of a prototype in scope, if the
  1126.      first argument is a floating point, it is passed in a floating
  1127.      point register, rather than an integer register.
  1128.  
  1129.      If the code is rewritten to use the ANSI standard `stdarg.h'
  1130.      method of variable arguments, and the prototype is in scope at the
  1131.      time of the call, everything will work fine.
  1132.  
  1134. File: gcc.info,  Node: C++ Misunderstandings,  Next: Protoize Caveats,  Prev: Disappointments,  Up: Trouble
  1135.  
  1136. Common Misunderstandings with GNU C++
  1137. =====================================
  1138.  
  1139.    C++ is a complex language and an evolving one, and its standard
  1140. definition (the ANSI C++ draft standard) is also evolving.  As a result,
  1141. your C++ compiler may occasionally surprise you, even when its behavior
  1142. is correct.  This section discusses some areas that frequently give
  1143. rise to questions of this sort.
  1144.  
  1145. * Menu:
  1146.  
  1147. * Static Definitions::  Static member declarations are not definitions
  1148. * Temporaries::         Temporaries may vanish before you expect
  1149.  
  1151. File: gcc.info,  Node: Static Definitions,  Next: Temporaries,  Up: C++ Misunderstandings
  1152.  
  1153. Declare *and* Define Static Members
  1154. -----------------------------------
  1155.  
  1156.    When a class has static data members, it is not enough to *declare*
  1157. the static member; you must also *define* it.  For example:
  1158.  
  1159.      class Foo
  1160.      {
  1161.        ...
  1162.        void method();
  1163.        static int bar;
  1164.      };
  1165.  
  1166.    This declaration only establishes that the class `Foo' has an `int'
  1167. named `Foo::bar', and a member function named `Foo::method'.  But you
  1168. still need to define *both* `method' and `bar' elsewhere.  According to
  1169. the draft ANSI standard, you must supply an initializer in one (and
  1170. only one) source file, such as:
  1171.  
  1172.      int Foo::bar = 0;
  1173.  
  1174.    Other C++ compilers may not correctly implement the standard
  1175. behavior.  As a result, when you switch to `g++' from one of these
  1176. compilers, you may discover that a program that appeared to work
  1177. correctly in fact does not conform to the standard: `g++' reports as
  1178. undefined symbols any static data members that lack definitions.
  1179.  
  1180. ə